(function webpackUniversalModuleDefinition(root, factory) {
  if(typeof exports === 'object' && typeof module === 'object')
    module.exports = factory(require("echarts"));
  else if(typeof define === 'function' && define.amd)
    define(["echarts"], factory);
  else if(typeof exports === 'object')
    exports["dataTool"] = factory(require("echarts"));
  else
    root["echarts"] = root["echarts"] || {}, root["echarts"]["dataTool"] = factory(root["echarts"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_1__) {
return /******/ (function(modules) { // webpackBootstrap
/******/  // The module cache
/******/  var installedModules = {};

/******/  // The require function
/******/  function __webpack_require__(moduleId) {

/******/    // Check if module is in cache
/******/    if(installedModules[moduleId])
/******/      return installedModules[moduleId].exports;

/******/    // Create a new module (and put it into the cache)
/******/    var module = installedModules[moduleId] = {
/******/      exports: {},
/******/      id: moduleId,
/******/      loaded: false
/******/    };

/******/    // Execute the module function
/******/    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/    // Flag the module as loaded
/******/    module.loaded = true;

/******/    // Return the exports of the module
/******/    return module.exports;
/******/  }


/******/  // expose the modules object (__webpack_modules__)
/******/  __webpack_require__.m = modules;

/******/  // expose the module cache
/******/  __webpack_require__.c = installedModules;

/******/  // __webpack_public_path__
/******/  __webpack_require__.p = "";

/******/  // Load entry module and return exports
/******/  return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

  var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {
      var echarts = __webpack_require__(1);
      echarts.dataTool = {
          version: '1.0.0',
          gexf: __webpack_require__(5),
          prepareBoxplotData: __webpack_require__(6)
      };
      return echarts.dataTool;
  }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ },
/* 1 */
/***/ function(module, exports) {

  module.exports = __WEBPACK_EXTERNAL_MODULE_1__;

/***/ },
/* 2 */,
/* 3 */,
/* 4 */,
/* 5 */
/***/ function(module, exports, __webpack_require__) {

  var __WEBPACK_AMD_DEFINE_RESULT__;// GEXF File Parser
  // http://gexf.net/1.2draft/gexf-12draft-primer.pdf
  !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {

      'use strict';
      var zrUtil = __webpack_require__(1).util;

      function parse(xml) {
          var doc;
          if (typeof xml === 'string') {
              var parser = new DOMParser();
              doc = parser.parseFromString(xml, 'text/xml');
          }
          else {
              doc = xml;
          }
          if (!doc || doc.getElementsByTagName('parsererror').length) {
              return null;
          }

          var gexfRoot = getChildByTagName(doc, 'gexf');

          if (!gexfRoot) {
              return null;
          }

          var graphRoot = getChildByTagName(gexfRoot, 'graph');

          var attributes = parseAttributes(getChildByTagName(graphRoot, 'attributes'));
          var attributesMap = {};
          for (var i = 0; i < attributes.length; i++) {
              attributesMap[attributes[i].id] = attributes[i];
          }

          return {
              nodes: parseNodes(getChildByTagName(graphRoot, 'nodes'), attributesMap),
              links: parseEdges(getChildByTagName(graphRoot, 'edges'))
          };
      }

      function parseAttributes(parent) {
          return parent ? zrUtil.map(getChildrenByTagName(parent, 'attribute'), function (attribDom) {
              return {
                  id: getAttr(attribDom, 'id'),
                  title: getAttr(attribDom, 'title'),
                  type: getAttr(attribDom, 'type')
              };
          }) : [];
      }

      function parseNodes(parent, attributesMap) {
          return parent ? zrUtil.map(getChildrenByTagName(parent, 'node'), function (nodeDom) {

              var id = getAttr(nodeDom, 'id');
              var label = getAttr(nodeDom, 'label');

              var node = {
                  id: id,
                  name: label,
                  itemStyle: {
                      normal: {}
                  }
              };

              var vizSizeDom = getChildByTagName(nodeDom, 'viz:size');
              var vizPosDom = getChildByTagName(nodeDom, 'viz:position');
              var vizColorDom = getChildByTagName(nodeDom, 'viz:color');
              // var vizShapeDom = getChildByTagName(nodeDom, 'viz:shape');

              var attvaluesDom = getChildByTagName(nodeDom, 'attvalues');

              if (vizSizeDom) {
                  node.symbolSize = parseFloat(getAttr(vizSizeDom, 'value'));
              }
              if (vizPosDom) {
                  node.x = parseFloat(getAttr(vizPosDom, 'x'));
                  node.y = parseFloat(getAttr(vizPosDom, 'y'));
                  // z
              }
              if (vizColorDom) {
                  node.itemStyle.normal.color = 'rgb(' +[
                      getAttr(vizColorDom, 'r') | 0,
                      getAttr(vizColorDom, 'g') | 0,
                      getAttr(vizColorDom, 'b') | 0
                  ].join(',') + ')';
              }
              // if (vizShapeDom) {
                  // node.shape = getAttr(vizShapeDom, 'shape');
              // }
              if (attvaluesDom) {
                  var attvalueDomList = getChildrenByTagName(attvaluesDom, 'attvalue');

                  node.attributes = {};

                  for (var j = 0; j < attvalueDomList.length; j++) {
                      var attvalueDom = attvalueDomList[j];
                      var attId = getAttr(attvalueDom, 'for');
                      var attValue = getAttr(attvalueDom, 'value');
                      var attribute = attributesMap[attId];

                      if (attribute) {
                          switch (attribute.type) {
                              case 'integer':
                              case 'long':
                                  attValue = parseInt(attValue, 10);
                                  break;
                              case 'float':
                              case 'double':
                                  attValue = parseFloat(attValue);
                                  break;
                              case 'boolean':
                                  attValue = attValue.toLowerCase() == 'true';
                                  break;
                              default:
                          }
                          node.attributes[attId] = attValue;
                      }
                  }
              }

              return node;
          }) : [];
      }

      function parseEdges(parent) {
          return parent ? zrUtil.map(getChildrenByTagName(parent, 'edge'), function (edgeDom) {
              var id = getAttr(edgeDom, 'id');
              var label = getAttr(edgeDom, 'label');

              var sourceId = getAttr(edgeDom, 'source');
              var targetId = getAttr(edgeDom, 'target');

              var edge = {
                  id: id,
                  name: label,
                  source: sourceId,
                  target: targetId,
                  lineStyle: {
                      normal: {}
                  }
              };

              var lineStyle = edge.lineStyle.normal;

              var vizThicknessDom = getChildByTagName(edgeDom, 'viz:thickness');
              var vizColorDom = getChildByTagName(edgeDom, 'viz:color');
              // var vizShapeDom = getChildByTagName(edgeDom, 'viz:shape');

              if (vizThicknessDom) {
                  lineStyle.width = parseFloat(vizThicknessDom.getAttribute('value'));
              }
              if (vizColorDom) {
                  lineStyle.color = 'rgb(' + [
                      getAttr(vizColorDom, 'r') | 0,
                      getAttr(vizColorDom, 'g') | 0,
                      getAttr(vizColorDom, 'b') | 0
                  ].join(',') + ')';
              }
              // if (vizShapeDom) {
              //     edge.shape = vizShapeDom.getAttribute('shape');
              // }

              return edge;
          }) : [];
      }

      function getAttr(el, attrName) {
          return el.getAttribute(attrName);
      }

      function getChildByTagName (parent, tagName) {
          var node = parent.firstChild;

          while (node) {
              if (
                  node.nodeType != 1 ||
                  node.nodeName.toLowerCase() != tagName.toLowerCase()
              ) {
                  node = node.nextSibling;
              } else {
                  return node;
              }
          }

          return null;
      }

      function getChildrenByTagName (parent, tagName) {
          var node = parent.firstChild;
          var children = [];
          while (node) {
              if (node.nodeName.toLowerCase() == tagName.toLowerCase()) {
                  children.push(node);
              }
              node = node.nextSibling;
          }

          return children;
      }

      return {
          parse: parse
      };
  }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

  var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {

      var quantile = __webpack_require__(7);
      var numberUtil = __webpack_require__(1).number;

      /**
       * Helper method for preparing data.
       * @param {Array.<number>} rawData like
       *        [
       *            [12,232,443], (raw data set for the first box)
       *            [3843,5545,1232], (raw datat set for the second box)
       *            ...
       *        ]
       * @param {Object} [opt]
       *
       * @param {(number|string)} [opt.boundIQR=1.5] Data less than min bound is outlier.
       *                          default 1.5, means Q1 - 1.5 * (Q3 - Q1).
       *                          If pass 'none', min bound will not be used.
       * @param {(number|string)} [opt.layout='horizontal']
       *                          Box plot layout, can be 'horizontal' or 'vertical'
       */
      return function (rawData, opt) {
          opt = opt || [];
          var boxData = [];
          var outliers = [];
          var axisData = [];
          var boundIQR = opt.boundIQR;

          for (var i = 0; i < rawData.length; i++) {
              axisData.push(i + '');
              var ascList = numberUtil.asc(rawData[i].slice());

              var Q1 = quantile(ascList, 0.25);
              var Q2 = quantile(ascList, 0.5);
              var Q3 = quantile(ascList, 0.75);
              var IQR = Q3 - Q1;

              var low = boundIQR === 'none'
                  ? ascList[0]
                  : Q1 - (boundIQR == null ? 1.5 : boundIQR) * IQR;
              var high = boundIQR === 'none'
                  ? ascList[ascList.length - 1]
                  : Q3 + (boundIQR == null ? 1.5 : boundIQR) * IQR;

              boxData.push([low, Q1, Q2, Q3, high]);

              for (var j = 0; j < ascList.length; j++) {
                  var dataItem = ascList[j];
                  if (dataItem < low || dataItem > high) {
                      var outlier = [i, dataItem];
                      opt.layout === 'vertical' && outlier.reverse();
                      outliers.push(outlier);
                  }
              }
          }
          return {
              boxData: boxData,
              outliers: outliers,
              axisData: axisData
          };
      };

  }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

  var __WEBPACK_AMD_DEFINE_RESULT__;/**
   * Copyright (c) 2010-2015, Michael Bostock
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * * Redistributions of source code must retain the above copyright notice, this
   *   list of conditions and the following disclaimer.
   *
   * * Redistributions in binary form must reproduce the above copyright notice,
   *   this list of conditions and the following disclaimer in the documentation
   *   and/or other materials provided with the distribution.
   *
   * * The name Michael Bostock may not be used to endorse or promote products
   *   derived from this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
   * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) {

      /**
       * @see <https://github.com/mbostock/d3/blob/master/src/arrays/quantile.js>
       * @see <http://en.wikipedia.org/wiki/Quantile>
       * @param {Array.<number>} ascArr
       */
      return function(ascArr, p) {
          var H = (ascArr.length - 1) * p + 1,
              h = Math.floor(H),
              v = +ascArr[h - 1],
              e = H - h;
          return e ? v + e * (ascArr[h] - v) : v;
      };

  }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ }
/******/ ])
});
;
